package edu.fasta.sisinfo2.poker;

import java.util.*;

import edu.fasta.sisinfo2.builders.BuilderJuegos;
import edu.fasta.sisinfo2.builders.CartaAltaBuilder;
import edu.fasta.sisinfo2.builders.ColorBuilder;
import edu.fasta.sisinfo2.builders.DobleParBuilder;
import edu.fasta.sisinfo2.builders.EscaleraBuilder;
import edu.fasta.sisinfo2.builders.EscaleraColorBuilder;
import edu.fasta.sisinfo2.builders.EscaleraRealBuilder;
import edu.fasta.sisinfo2.builders.FullBuilder;
import edu.fasta.sisinfo2.builders.ParBuilder;
import edu.fasta.sisinfo2.builders.PokerBuilder;
import edu.fasta.sisinfo2.builders.TrioBuilder;
import edu.fasta.sisinfo2.juegos.EscaleraColor;
import edu.fasta.sisinfo2.juegos.Full;
import edu.fasta.sisinfo2.juegos.Juego;
import edu.fasta.sisinfo2.juegos.Par;
import edu.fasta.sisinfo2.juegos.Trio;


public class TexasPoker {
        private List listaJugadores;
        private Pozo pozo;
        private JugadorImplementacion dealer;
        private JugadorImplementacion ultimoEnSubir;
        private JugadorImplementacion jugadorInicial;
        private JugadorImplementacion jugadorConCiegaGrande;
        private JugadorImplementacion jugadorConCiegaChica;
        private MesaEstandar laMesa;
        private int rondaApuestas;
        
        

        

        public TexasPoker(){
                this.setLaMesa(new MesaEstandar());
                this.setPozo(new Pozo());
                this.setDealer(null);
                this.setListaJugadores(new ArrayList());
                
        }
        
        public static void main(String[] args) {
                
                //creamos el juego
                TexasPoker unPoker = new TexasPoker();
                
                //creamos los jugadores
                
                unPoker.agregarJugador(new JugadorImplementacion("Pepito1"));
                unPoker.agregarJugador(new JugadorImplementacion("Juancho2"));
                unPoker.agregarJugador(new JugadorImplementacion("Player3"));
                unPoker.agregarJugador(new JugadorImplementacion("Andres4"));
                unPoker.agregarJugador(new JugadorImplementacion("Guille5"));
                
                
//                
//                while((unPoker.jugadoresActivos(unPoker.getListaJugadores()) > 1) && (unPoker.getRondaApuestas() < 5)){
//                        
//                        //TODO activar jugadores
//                        
//                        if(unPoker.getDealer() == null){
//                                unPoker.setDealer((JugadorImplementacion)unPoker.getListaJugadores().get(0));
//                        }else{
//                                int sizeLista = unPoker.getListaJugadores().size();
//                                int indiceDealer = unPoker.getListaJugadores().indexOf(unPoker.getDealer());
//                                
//                                if(indiceDealer != sizeLista){
//                                        
//                                }
//                                
//                                
//                        }
//                }
//                
                
                
                
                
                
                
                
                
                
                
                
                
//              //probamos sacar una carta del mazo e imprimirla
//              //System.out.println("Dame carta: " + unPoker.getLaMesa().getMazo().sacarCarta().imprimirla());
//              
//              //cargamos las apuestas
//              Iterator it = unPoker.getListaJugadores().iterator();
//              JugadorImplementacion jAux;
//              while(it.hasNext()){
//                      jAux = (JugadorImplementacion)it.next();
//                      unPoker.getPozo().agregarApuesta(jAux.getApuesta());
//                      System.out.println("Se agrego la apuesta de: " + jAux.getNombre());
//                      System.out.println("Apuesta: " + jAux.getApuesta().getValor());
//              }
//              
//              //seteamos el dealer
////            Iterator it2 = unPoker.getListaJugadores().iterator();
////            while(it2.hasNext()){
////                    unPoker.setDealer((JugadorImplementacion)it2.next()); 
////            }
//              unPoker.setDealer((JugadorImplementacion) unPoker.getListaJugadores().get(unPoker.getListaJugadores().size()-1));
//              System.out.println("Jugador dealer: " + unPoker.getDealer().getNombre());
//              
//              //seteamos el jugador inicial
/*              Iterator it5 = unPoker.getListaJugadores().iterator();
                JugadorImplementacion jx;
                jx = (JugadorImplementacion) it5.next();
                unPoker.setJugadorInicial(jx);
                System.out.println("Jugador inicial: " + (jx.getNombre()));
                
//              
//              //seteamos el jugador con ciega chica
//              unPoker.setJugadorConCiegaChica(unPoker.getJugadorInicial());
//              unPoker.getJugadorConCiegaChica().getApuesta().subirApuesta(unPoker.getLaMesa().getCiegaChica());
//              System.out.println("Jugador con ciega chica: " + unPoker.getJugadorConCiegaChica().getNombre());
//              System.out.println("La apuesta de " +  unPoker.getJugadorConCiegaChica().getNombre() + " es: " + unPoker.getJugadorConCiegaChica().getApuesta().getValor());
//              unPoker.setUltimoEnSubir(unPoker.getJugadorConCiegaChica()); //el jugador inicial pasa a ser el ultimo en subir
//              System.out.println("El ultimo en subir es: " + unPoker.getUltimoEnSubir().getNombre());
//              
//              //seteamos el jugador con ciega grande
//              it = unPoker.getListaJugadores().iterator();
//              boolean flag = true;
//              while(it.hasNext() && flag){
//                      if(it.next().equals(unPoker.jugadorConCiegaChica)){
//                              unPoker.setJugadorConCiegaGrande((JugadorImplementacion) it.next()); 
//                              unPoker.getJugadorConCiegaGrande().getApuesta().subirApuesta(unPoker.getLaMesa().getCiegaGrande()); //el valor de la ciega grande esta en la mesa
//                              flag = false;
//                      }
//              }
//              System.out.println("Jugador con ciega grande: " + unPoker.getJugadorConCiegaGrande().getNombre());
//              System.out.println("La apuesta de " +  unPoker.getJugadorConCiegaGrande().getNombre() + " es: " + unPoker.getJugadorConCiegaGrande().getApuesta().getValor());
//              unPoker.setUltimoEnSubir(unPoker.jugadorConCiegaGrande); //el segundo jugador pasa a ser el ultimo en subir
//              System.out.println("El ultimo en subir es: " + unPoker.getUltimoEnSubir().getNombre());
//              
//              //imprimir apuestas
//              Iterator it3 = unPoker.getListaJugadores().iterator();
//              while(it3.hasNext()){
//                      jAux = (JugadorImplementacion)it3.next();
//                      System.out.println("Apuestas..: " + jAux.getApuesta().getValor());
//              }
//                              
//              //imprimiento las cartas de los jugadores
//              unPoker.getLaMesa().repartirInicial(unPoker.getListaJugadores());
//              Iterator it4 = unPoker.getListaJugadores().iterator();
//              JugadorImplementacion j;
//              while(it4.hasNext()){
        //              j =  (JugadorImplementacion)it4.next();
        //              System.out.println( j.getNombre() + " tiene " + ((Carta)j.getMano().getCartasJugador().get(0)).imprimirla());
        //              System.out.println( j.getNombre() + " tiene " + ((Carta)j.getMano().getCartasJugador().get(1)).imprimirla());
        //      }
//              
//              //Muestra el flop (le da las cartas a cada jugador)
//              unPoker.getLaMesa().imprimirFlop();
                
                
//              
//              //Muestra el Turn (le da la carta a cada jugador)
//              unPoker.getLaMesa().imprimirTurn();
                
//              
//              //Muestra el River (le da 1 carta a cada jugador)
//              unPoker.getLaMesa().imprimirRiver();
                
//              
//              //imprimiento las cartas de los jugadores
//              unPoker.getLaMesa().repartirInicial(unPoker.getListaJugadores());
//              it4 = unPoker.getListaJugadores().iterator();
//              while(it4.hasNext()){
//                      j =  (JugadorImplementacion)it4.next();
//                      Iterator cartasMesa = j.getMano().getCartasMesa().iterator();
//                      while(cartasMesa.hasNext()){
//                              Carta unaCarta = (Carta) cartasMesa.next();
//                              System.out.println( j.getNombre() + " tiene de la mesa " + unaCarta.imprimirla());
//                      }
//              }       
//              //Calcular pozo total
//              System.out.println("Pozo: " + unPoker.getPozo().getPozoTotal());
/*              
                JugadorImplementacion jp = (JugadorImplementacion) listaJugadores.get(0);
                JugadorImplementacion jp2 = (JugadorImplementacion) listaJugadores.get(1);
                
                unPoker.laMesa.getMazo().mezclar();
                
                unPoker.laMesa.ponerFlop();
                unPoker.laMesa.mostrarFlop();
                unPoker.laMesa.ponerTurn();
                unPoker.laMesa.mostrarTurn();
                unPoker.laMesa.ponerRiver();
                unPoker.laMesa.mostrarRiver();
                
                jp.getMano().agregarCartaDeJugador(unPoker.laMesa.getMazo().sacarCarta());
                jp.getMano().agregarCartaDeJugador(unPoker.laMesa.getMazo().sacarCarta());
                jp2.getMano().agregarCartaDeJugador(unPoker.laMesa.getMazo().sacarCarta());
                jp2.getMano().agregarCartaDeJugador(unPoker.laMesa.getMazo().sacarCarta());
                
                System.out.println(jp.getNombre()+ ": " +((Carta) jp.getMano().getCartasJugador().get(0)).imprimirla());
                System.out.println(jp.getNombre()+ ": " +((Carta) jp.getMano().getCartasJugador().get(1)).imprimirla());
                
                jp.getMano().setCartasMesa(unPoker.laMesa.getCartasSobreLaMesa());
                jp2.getMano().setCartasMesa(unPoker.laMesa.getCartasSobreLaMesa());
                
                jp.getMano().cargarTodasLasCartas();
                jp2.getMano().cargarTodasLasCartas();

                //jp.getMano().combinatoria();
                /*
                int c=0;
                Iterator iterator = jp.getMano().getMejorMano().iterator();
                while(iterator.hasNext()){
                        Carta unaCarta = (Carta) iterator.next();
                        System.out.println(c++ + " :" + unaCarta.imprimirla());
                }*/             
                
                BuilderJuegos sig = new EscaleraColorBuilder(
                                                        new PokerBuilder(
                                                        new FullBuilder(
                                                        new ColorBuilder(
                                                        new EscaleraBuilder(
                                                        new TrioBuilder(
                                                        new DobleParBuilder(
                                                        new ParBuilder(
                                                        new CartaAltaBuilder()))))))));
                
                EscaleraRealBuilder erb = new EscaleraRealBuilder(sig);
                
                Mano manoPrueba = new Mano();
                Mano otraMano = new Mano();
                Mano manoPrueba1 = new Mano();
                
                //************* Prueba de crear una ESCALERA REAL *****************//
/*              
                manoPrueba.agregarCartaDeJugador(new Carta(0, 0)); //A
                manoPrueba.agregarCartaDeJugador(new Carta(0, 9)); //10 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 10)); //J
                manoPrueba.agregarCartaDeMesa(new Carta(2, 11)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 12)); //K
                manoPrueba.agregarCartaDeMesa(new Carta(0, 11)); //Q
                manoPrueba.agregarCartaDeMesa(new Carta(3, 10)); 
*/              
                //****************************************************************//

//                //************* Prueba de crear una ESCALERA COLOR *****************//
//              
//                manoPrueba.agregarCartaDeJugador(new Carta(1, 3)); 
//                manoPrueba.agregarCartaDeJugador(new Carta(1, 4)); 
//                manoPrueba.agregarCartaDeMesa(new Carta(1, 6)); 
//                manoPrueba.agregarCartaDeMesa(new Carta(2, 11)); 
//                manoPrueba.agregarCartaDeMesa(new Carta(3, 12)); 
//                manoPrueba.agregarCartaDeMesa(new Carta(1, 5)); 
//                manoPrueba.agregarCartaDeMesa(new Carta(1, 7)); 
//                
//                otraMano.agregarCartaDeJugador(new Carta(1, 5)); 
//                otraMano.agregarCartaDeJugador(new Carta(1, 6)); 
//                otraMano.agregarCartaDeMesa(new Carta(1, 7)); 
//                otraMano.agregarCartaDeMesa(new Carta(2, 11)); 
//                otraMano.agregarCartaDeMesa(new Carta(3, 12)); 
//                otraMano.agregarCartaDeMesa(new Carta(1, 8)); 
//                otraMano.agregarCartaDeMesa(new Carta(1, 9)); 
//                
//                manoPrueba1.agregarCartaDeJugador(new Carta(1, 3)); 
//                manoPrueba1.agregarCartaDeJugador(new Carta(1, 4)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(1, 6)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(2, 11)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(3, 0)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(1, 5)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(1, 7)); 
//              
//                //****************************************************************//
                
                

                //************* Prueba de crear un POKER *****************//
                /*
                manoPrueba.agregarCartaDeJugador(new Carta(0, 3)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 4)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 3)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 3)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 0)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 7));                 
                */
                //****************************************************************//
                
                
                //************* Prueba de crear un FULL *****************//
              
                manoPrueba.agregarCartaDeJugador(new Carta(0, 6)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 7));    
                
//                manoPrueba1.agregarCartaDeJugador(new Carta(0, 3)); 
//                manoPrueba1.agregarCartaDeJugador(new Carta(1, 5)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(2, 5)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(0, 3)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(3, 3)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(1, 5)); 
//                manoPrueba1.agregarCartaDeMesa(new Carta(3, 7)); 
//                
//                //****************************************************************/
                
                //************* Prueba de crear un COLOR *****************//
/*              
                manoPrueba.agregarCartaDeJugador(new Carta(0, 6)); 
                manoPrueba.agregarCartaDeJugador(new Carta(0, 11)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 12)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 8)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 7));                 
        */      
                //****************************************************************/
                
                //************* Prueba de crear un ESCALERA *****************//
        /*      
                manoPrueba.agregarCartaDeJugador(new Carta(0, 9)); 
                manoPrueba.agregarCartaDeJugador(new Carta(0, 1)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 12)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 8)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 7));                 
                
                //****************************************************************/
                
                //************* Prueba de crear un TRIO *****************//
     /*           
                manoPrueba.agregarCartaDeJugador(new Carta(0, 3)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 3)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 5)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 7)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 12)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 8)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 3));                 
                
                //****************************************************************/
                
                //************* Prueba de crear un DOBLEPAR *****************//
                /*
                manoPrueba.agregarCartaDeJugador(new Carta(0, 3)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 2)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 11)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 2)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 12)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 8)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 11));                
                
                //****************************************************************/
                
                //************* Prueba de crear un PAR *****************//
     /*           
                manoPrueba.agregarCartaDeJugador(new Carta(0, 1)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 9)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 11)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 0)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 10));                
                
                //****************************************************************/
                
                //************* Prueba de crear una CARTAALTA *****************//
             /*   
                manoPrueba.agregarCartaDeJugador(new Carta(0, 1)); 
                manoPrueba.agregarCartaDeJugador(new Carta(1, 9)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 11)); 
                manoPrueba.agregarCartaDeMesa(new Carta(3, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(0, 0)); 
                manoPrueba.agregarCartaDeMesa(new Carta(1, 6)); 
                manoPrueba.agregarCartaDeMesa(new Carta(2, 10));                
                
                //****************************************************************/
                
                manoPrueba.cargarTodasLasCartas();
//                otraMano.cargarTodasLasCartas();
   //             manoPrueba1.cargarTodasLasCartas();
//
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(0)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(1)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(2)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(3)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(4)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(5)).imprimirla());
//                System.out.println(((Carta)manoPrueba.getTodasLasCartas().get(6)).imprimirla());
//                                
//                //************************************************************/
//                
//                
//                BuilderJuegos bj = new EscaleraColorBuilder(null);
//                EscaleraColor ec1;
//                EscaleraColor ec2;
//                
//                ec1 = (EscaleraColor) bj.buildJuego(manoPrueba);
//                ec2 = (EscaleraColor) bj.buildJuego(otraMano);
//                
//                if( ec1.compararJuego(ec2) != null){
//                	System.out.println("Escalera ganadora: " + ( (Carta) (((EscaleraColor)(ec1.compararJuego(ec2))).getCartas().get(0))).imprimirla() );
//                }else{
//                	System.out.println("Escaleras empatadas");
//                	//aca puedo comparar las 2 manos x carta alta
//                }
                
                Juego unJuego = erb.buildJuego(manoPrueba);
                
                
                System.out.println(  (((Carta)  ((Full) unJuego).getElTrio().getCartas().get(0)).imprimirla()));
                System.out.println(  (((Carta)  ((Full) unJuego).getElTrio().getCartas().get(1)).imprimirla()));
                System.out.println(  (((Carta)  ((Full) unJuego).getElTrio().getCartas().get(2)).imprimirla()));
                System.out.println(  (((Carta)  ((Full) unJuego).getElTrio().getCartas().get(0)).imprimirla()));
                System.out.println(  (((Carta)  ((Full) unJuego).getElTrio().getCartas().get(1)).imprimirla()));
                
         //       erb.buildJuego(manoPrueba1);
                
                
//              int r;
//              r = jp.getMano().comparar(jp.getMano(), jp2.getMano());
//              
//              System.out.println("Resultado: " + r);
                
                
        }
        
        
        public int jugadoresActivos(List listaJugadores){
                Iterator it = listaJugadores.iterator();
                int cant = 0;
                while(it.hasNext()){
                        if(((JugadorImplementacion)it.next()).isActivo())
                                cant++; 
                }
                return cant;
        }

        public void agregarJugador(JugadorImplementacion unJugador){
                this.getListaJugadores().add(unJugador);
        }
        
        public void sacarJugador(JugadorImplementacion unJugador){
                this.getListaJugadores().remove(unJugador);
        }
        
        
        public JugadorImplementacion getJugadorInicial() {
                return jugadorInicial;
        }

        public void setJugadorInicial(JugadorImplementacion jugadorInicial) {
                this.jugadorInicial = jugadorInicial;
        }

        public MesaEstandar getLaMesa() {
                return laMesa;
        }

        public void setLaMesa(MesaEstandar laMesa) {
                this.laMesa = laMesa;
        }

        public List getListaJugadores() {
                return listaJugadores;
        }

        public void setListaJugadores(List listaJugadores) {
                this.listaJugadores = listaJugadores;
        }

        public Pozo getPozo() {
                return pozo;
        }

        public void setPozo(Pozo pozo) {
                this.pozo = pozo;
        }

        public JugadorImplementacion getDealer() {
                return dealer;
        }

        public void setDealer(JugadorImplementacion dealer) {
                this.dealer = dealer;
        }

        public JugadorImplementacion getUltimoEnSubir() {
                return ultimoEnSubir;
        }

        public void setUltimoEnSubir(JugadorImplementacion ultimoEnSubir) {
                this.ultimoEnSubir = ultimoEnSubir;
        }

        public JugadorImplementacion getJugadorConCiegaGrande() {
                return jugadorConCiegaGrande;
        }

        public void setJugadorConCiegaGrande(JugadorImplementacion jugadorConCiegaGrande) {
                this.jugadorConCiegaGrande = jugadorConCiegaGrande;
        }

        public JugadorImplementacion getJugadorConCiegaChica() {
                return jugadorConCiegaChica;
        }

        public void setJugadorConCiegaChica(JugadorImplementacion jugadorConCiegaChica) {
                this.jugadorConCiegaChica = jugadorConCiegaChica;
        }
        public int getRondaApuestas() {
                return rondaApuestas;
        }

        public void setRondaApuestas(int rondaApuestas) {
                this.rondaApuestas = rondaApuestas;
        }
}